home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2000 March / maximum-cd-2000-03.iso / Quake3 Game Source / Q3AGameSource.exe / Main / cg_syscalls.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-18  |  8.0 KB  |  271 lines
  1. // Copyright (C) 1999-2000 Id Software, Inc.
  2. //
  3. // cg_syscalls.c -- this file is only included when building a dll
  4. // cg_syscalls.asm is included instead when building a qvm
  5. #include "cg_local.h"
  6.  
  7. static int (QDECL *syscall)( int arg, ... ) = (int (QDECL *)( int, ...))-1;
  8.  
  9.  
  10. void dllEntry( int (QDECL  *syscallptr)( int arg,... ) ) {
  11.     syscall = syscallptr;
  12. }
  13.  
  14.  
  15. int PASSFLOAT( float x ) {
  16.     float    floatTemp;
  17.     floatTemp = x;
  18.     return *(int *)&floatTemp;
  19. }
  20.  
  21. void    trap_Print( const char *fmt ) {
  22.     syscall( CG_PRINT, fmt );
  23. }
  24.  
  25. void    trap_Error( const char *fmt ) {
  26.     syscall( CG_ERROR, fmt );
  27. }
  28.  
  29. int        trap_Milliseconds( void ) {
  30.     return syscall( CG_MILLISECONDS ); 
  31. }
  32.  
  33. void    trap_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags ) {
  34.     syscall( CG_CVAR_REGISTER, vmCvar, varName, defaultValue, flags );
  35. }
  36.  
  37. void    trap_Cvar_Update( vmCvar_t *vmCvar ) {
  38.     syscall( CG_CVAR_UPDATE, vmCvar );
  39. }
  40.  
  41. void    trap_Cvar_Set( const char *var_name, const char *value ) {
  42.     syscall( CG_CVAR_SET, var_name, value );
  43. }
  44.  
  45. void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
  46.     syscall( CG_CVAR_VARIABLESTRINGBUFFER, var_name, buffer, bufsize );
  47. }
  48.  
  49. int        trap_Argc( void ) {
  50.     return syscall( CG_ARGC );
  51. }
  52.  
  53. void    trap_Argv( int n, char *buffer, int bufferLength ) {
  54.     syscall( CG_ARGV, n, buffer, bufferLength );
  55. }
  56.  
  57. void    trap_Args( char *buffer, int bufferLength ) {
  58.     syscall( CG_ARGS, buffer, bufferLength );
  59. }
  60.  
  61. int        trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
  62.     return syscall( CG_FS_FOPENFILE, qpath, f, mode );
  63. }
  64.  
  65. void    trap_FS_Read( void *buffer, int len, fileHandle_t f ) {
  66.     syscall( CG_FS_READ, buffer, len, f );
  67. }
  68.  
  69. void    trap_FS_Write( const void *buffer, int len, fileHandle_t f ) {
  70.     syscall( CG_FS_WRITE, buffer, len, f );
  71. }
  72.  
  73. void    trap_FS_FCloseFile( fileHandle_t f ) {
  74.     syscall( CG_FS_FCLOSEFILE, f );
  75. }
  76.  
  77. void    trap_SendConsoleCommand( const char *text ) {
  78.     syscall( CG_SENDCONSOLECOMMAND, text );
  79. }
  80.  
  81. void    trap_AddCommand( const char *cmdName ) {
  82.     syscall( CG_ADDCOMMAND, cmdName );
  83. }
  84.  
  85. void    trap_SendClientCommand( const char *s ) {
  86.     syscall( CG_SENDCLIENTCOMMAND, s );
  87. }
  88.  
  89. void    trap_UpdateScreen( void ) {
  90.     syscall( CG_UPDATESCREEN );
  91. }
  92.  
  93. void    trap_CM_LoadMap( const char *mapname ) {
  94.     syscall( CG_CM_LOADMAP, mapname );
  95. }
  96.  
  97. int        trap_CM_NumInlineModels( void ) {
  98.     return syscall( CG_CM_NUMINLINEMODELS );
  99. }
  100.  
  101. clipHandle_t trap_CM_InlineModel( int index ) {
  102.     return syscall( CG_CM_INLINEMODEL, index );
  103. }
  104.  
  105. clipHandle_t trap_CM_TempBoxModel( const vec3_t mins, const vec3_t maxs ) {
  106.     return syscall( CG_CM_TEMPBOXMODEL, mins, maxs );
  107. }
  108.  
  109. int        trap_CM_PointContents( const vec3_t p, clipHandle_t model ) {
  110.     return syscall( CG_CM_POINTCONTENTS, p, model );
  111. }
  112.  
  113. int        trap_CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles ) {
  114.     return syscall( CG_CM_TRANSFORMEDPOINTCONTENTS, p, model, origin, angles );
  115. }
  116.  
  117. void    trap_CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
  118.                           const vec3_t mins, const vec3_t maxs,
  119.                           clipHandle_t model, int brushmask ) {
  120.     syscall( CG_CM_BOXTRACE, results, start, end, mins, maxs, model, brushmask );
  121. }
  122.  
  123. void    trap_CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
  124.                           const vec3_t mins, const vec3_t maxs,
  125.                           clipHandle_t model, int brushmask,
  126.                           const vec3_t origin, const vec3_t angles ) {
  127.     syscall( CG_CM_TRANSFORMEDBOXTRACE, results, start, end, mins, maxs, model, brushmask, origin, angles );
  128. }
  129.  
  130. int        trap_CM_MarkFragments( int numPoints, const vec3_t *points, 
  131.                 const vec3_t projection,
  132.                 int maxPoints, vec3_t pointBuffer,
  133.                 int maxFragments, markFragment_t *fragmentBuffer ) {
  134.     return syscall( CG_CM_MARKFRAGMENTS, numPoints, points, projection, maxPoints, pointBuffer, maxFragments, fragmentBuffer );
  135. }
  136.  
  137. void    trap_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx ) {
  138.     syscall( CG_S_STARTSOUND, origin, entityNum, entchannel, sfx );
  139. }
  140.  
  141. void    trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum ) {
  142.     syscall( CG_S_STARTLOCALSOUND, sfx, channelNum );
  143. }
  144.  
  145. void    trap_S_ClearLoopingSounds( void ) {
  146.     syscall( CG_S_CLEARLOOPINGSOUNDS );
  147. }
  148.  
  149. void    trap_S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx ) {
  150.     syscall( CG_S_ADDLOOPINGSOUND, entityNum, origin, velocity, sfx );
  151. }
  152.  
  153. void    trap_S_UpdateEntityPosition( int entityNum, const vec3_t origin ) {
  154.     syscall( CG_S_UPDATEENTITYPOSITION, entityNum, origin );
  155. }
  156.  
  157. void    trap_S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater ) {
  158.     syscall( CG_S_RESPATIALIZE, entityNum, origin, axis, inwater );
  159. }
  160.  
  161. sfxHandle_t    trap_S_RegisterSound( const char *sample ) {
  162.     return syscall( CG_S_REGISTERSOUND, sample );
  163. }
  164.  
  165. void    trap_S_StartBackgroundTrack( const char *intro, const char *loop ) {
  166.     syscall( CG_S_STARTBACKGROUNDTRACK, intro, loop );
  167. }
  168.  
  169. void    trap_R_LoadWorldMap( const char *mapname ) {
  170.     syscall( CG_R_LOADWORLDMAP, mapname );
  171. }
  172.  
  173. qhandle_t trap_R_RegisterModel( const char *name ) {
  174.     return syscall( CG_R_REGISTERMODEL, name );
  175. }
  176.  
  177. qhandle_t trap_R_RegisterSkin( const char *name ) {
  178.     return syscall( CG_R_REGISTERSKIN, name );
  179. }
  180.  
  181. qhandle_t trap_R_RegisterShader( const char *name ) {
  182.     return syscall( CG_R_REGISTERSHADER, name );
  183. }
  184.  
  185. qhandle_t trap_R_RegisterShaderNoMip( const char *name ) {
  186.     return syscall( CG_R_REGISTERSHADERNOMIP, name );
  187. }
  188.  
  189. void    trap_R_ClearScene( void ) {
  190.     syscall( CG_R_CLEARSCENE );
  191. }
  192.  
  193. void    trap_R_AddRefEntityToScene( const refEntity_t *re ) {
  194.     syscall( CG_R_ADDREFENTITYTOSCENE, re );
  195. }
  196.  
  197. void    trap_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts ) {
  198.     syscall( CG_R_ADDPOLYTOSCENE, hShader, numVerts, verts );
  199. }
  200.  
  201. void    trap_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
  202.     syscall( CG_R_ADDLIGHTTOSCENE, org, PASSFLOAT(intensity), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b) );
  203. }
  204.  
  205. void    trap_R_RenderScene( const refdef_t *fd ) {
  206.     syscall( CG_R_RENDERSCENE, fd );
  207. }
  208.  
  209. void    trap_R_SetColor( const float *rgba ) {
  210.     syscall( CG_R_SETCOLOR, rgba );
  211. }
  212.  
  213. void    trap_R_DrawStretchPic( float x, float y, float w, float h, 
  214.                                float s1, float t1, float s2, float t2, qhandle_t hShader ) {
  215.     syscall( CG_R_DRAWSTRETCHPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), hShader );
  216. }
  217.  
  218. void    trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs ) {
  219.     syscall( CG_R_MODELBOUNDS, model, mins, maxs );
  220. }
  221.  
  222. void    trap_R_LerpTag( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, 
  223.                        float frac, const char *tagName ) {
  224.     syscall( CG_R_LERPTAG, tag, mod, startFrame, endFrame, PASSFLOAT(frac), tagName );
  225. }
  226.  
  227. void        trap_GetGlconfig( glconfig_t *glconfig ) {
  228.     syscall( CG_GETGLCONFIG, glconfig );
  229. }
  230.  
  231. void        trap_GetGameState( gameState_t *gamestate ) {
  232.     syscall( CG_GETGAMESTATE, gamestate );
  233. }
  234.  
  235. void        trap_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime ) {
  236.     syscall( CG_GETCURRENTSNAPSHOTNUMBER, snapshotNumber, serverTime );
  237. }
  238.  
  239. qboolean    trap_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
  240.     return syscall( CG_GETSNAPSHOT, snapshotNumber, snapshot );
  241. }
  242.  
  243. qboolean    trap_GetServerCommand( int serverCommandNumber ) {
  244.     return syscall( CG_GETSERVERCOMMAND, serverCommandNumber );
  245. }
  246.  
  247. int            trap_GetCurrentCmdNumber( void ) {
  248.     return syscall( CG_GETCURRENTCMDNUMBER );
  249. }
  250.  
  251. qboolean    trap_GetUserCmd( int cmdNumber, usercmd_t *ucmd ) {
  252.     return syscall( CG_GETUSERCMD, cmdNumber, ucmd );
  253. }
  254.  
  255. void        trap_SetUserCmdValue( int stateValue, float sensitivityScale ) {
  256.     syscall( CG_SETUSERCMDVALUE, stateValue, PASSFLOAT(sensitivityScale) );
  257. }
  258.  
  259. void        testPrintInt( char *string, int i ) {
  260.     syscall( CG_TESTPRINTINT, string, i );
  261. }
  262.  
  263. void        testPrintFloat( char *string, float f ) {
  264.     syscall( CG_TESTPRINTFLOAT, string, PASSFLOAT(f) );
  265. }
  266.  
  267. int trap_MemoryRemaining( void ) {
  268.     return syscall( CG_MEMORY_REMAINING );
  269. }
  270.  
  271.